package Objetos 
{
	import flash.display.MovieClip;
	import flash.events.KeyboardEvent;
	import flash.media.Sound;
	import flash.media.SoundChannel;
	import flash.media.SoundTransform;
	import flash.ui.Keyboard;
	import Levels.Level;
	/**
	 * ...
	 * @author Leandro Moreira Lopes
	 */
	public class Heroi extends MovieClip
	{
		private var NB_velocidadeY			:Number;			/** * variavel de velocidade em Y do heroi*/
		private var NB_velocidadeX			:Number;			/** * variavel de velocidade em X do heroi*/
		private var NB_aceleracao			:Number;			/** * variavel de aceleracao*/
		private var NB_desaceleracao		:Number;			/** * variavel de desaceleracao*/
		private var NB_velocidadeMax		:Number;			/** * variavel de velocidade Max, diferente para cada nave*/
		private var NB_velocidadeRot		:Number;			/** * variavel de velocidade de rotacao, diferente para cada nave*/
		
		private var nave					:String;			/** * variavel que define qual a nave criada*/
		public var naveEscolhida			:MovieClip;			/** * variavel para o MC da skin da nave*/
		
		private var animacao				:String;			/** * variaveis para animacao*/
		private var animacaoCarregandoTiro	:String;
		public var MC_energiaDoTiro			:MovieClip;			/** * variavel para efeito de acumulo de energia para criar o tiro*/
		
		private var MC_tiro					:Tiro;				/** * variavel do tiro*/
		public var UI_vida					:int;				/** * variavel com HP dinamico do heroi*/
		public var UI_vidaMAX				:uint;				/** * variavel com HP Maximo do heroi (para calculo da barra de HP)*/
		public var UI_tempoComUpgrade		:uint;				/** * contador com o tempo do upgrade ativado*/
		
		private var BO_Acc					:Boolean;			/** * boleanas de controle*/
		private var BO_DesAcc				:Boolean;
		private var BO_Dir					:Boolean;
		private var BO_Esq					:Boolean;
		private var BO_Tiro					:Boolean;
		
		private var UI_contadorDoTiro		:uint;				/** * variavel de tempo ao carregar o tiro*/
		
		public var UI_player				:uint;				/** * variavel com o no. do player*/
		public var BO_pegouUpgrade			:Boolean;			/** * boleana caso tenha pego o upgrade*/
		public var UI_tipoDoTiro			:uint;				/** * variavel com o tipo de tiro de acordo com o "lado da força"*/
		public var UI_forcaDoTiro			:uint;				/** * variavel com a forca do tiro*/ 
		
		private var tiro1					:Sound = new somDoTiro1();				/** * variaveis dos sons de tiro*/
		private var tiro2					:Sound = new somDoTiro2();
		private var somTiro					:SoundChannel = new SoundChannel();
		private var carregandotiro1			:Sound = new canhao1();
		private var carregandotiro2			:Sound = new canhao2();
		private var somCanhao				:SoundChannel = new SoundChannel();
		
		private var turbina					:Sound = new fly();
		private var somTurbina				:SoundChannel = new SoundChannel();
		
		
		
		public function Heroi(player:uint,lado:uint, tipo:String) 
		{
			UI_player = player;
			UI_tempoComUpgrade = 600;							/** * definindo tempo de duração do upgrade*/
			UI_tipoDoTiro = lado;								/** * definindo que o tipo de tiro e passado pelo argumento da funcao construtora do heroi*/
			
			nave = tipo;										/** * definindo que o tipo de nave e passado pelo argumento da funcao construtora do heroi*/
			
			NB_velocidadeX = 0;									/** * velocidade inicial = 0*/
			NB_velocidadeY = 0;
			
			
			Main.getInstance().stage.addEventListener(KeyboardEvent.KEY_DOWN, pressionar, false, 0, true);		/** * eventos de keyboard para controle*/
			Main.getInstance().stage.addEventListener(KeyboardEvent.KEY_UP, soltar, false, 0, true);
			
			
			switch (nave)										/** * SWITCHs para cada nave, diferenciando a skin, UI_vida, velocidade de aceleracao e desaceleracao*/
			{													/** * velocidade MAX, velocidade de rotacao, e forca do tiro, especifico para cada nave*/
				case "XWing":
				naveEscolhida = new XWing();
				naveEscolhida.scaleX = 0.5;
				naveEscolhida.scaleY = 0.5;
				naveEscolhida.gotoAndStop(1);
				Main.getInstance().MC_tela.addChild(naveEscolhida);
				this.scaleX = 1.2;								/** * o MC do heroi e escalonado de acordo com a área de acerto de cada nave, aproximadamente*/
				this.scaleY = 1.3;								/** * mas seu alpha está em 0*/
				UI_vida = 300;
				NB_aceleracao = 0.6;									
				NB_desaceleracao = 0.3;								
				NB_velocidadeMax = 15;
				NB_velocidadeRot = 10;
				UI_forcaDoTiro = 10;
				break;
				
				case "YWing":
				naveEscolhida = new YWing();
				naveEscolhida.scaleX = 0.4;
				naveEscolhida.scaleY = 0.4;
				naveEscolhida.gotoAndStop(1);
				Main.getInstance().MC_tela.addChild(naveEscolhida);
				this.scaleX = 2.2;
				this.scaleY = 1.2;
				UI_vida = 300;
				NB_aceleracao = 0.4;									
				NB_desaceleracao = 0.2;								
				NB_velocidadeMax = 10;
				NB_velocidadeRot = 8;
				UI_forcaDoTiro = 15;
				break;
				
				case "Falcon":
				naveEscolhida = new Falcon();
				naveEscolhida.scaleX = 0.4;
				naveEscolhida.scaleY = 0.4;
				naveEscolhida.gotoAndStop(1);
				Main.getInstance().MC_tela.addChild(naveEscolhida);
				this.scaleX = 1.8;
				this.scaleY = 1.5;
				UI_vida = 500;
				NB_aceleracao = 0.2;									
				NB_desaceleracao = 0.1;								
				NB_velocidadeMax = 10;
				NB_velocidadeRot = 5;
				UI_forcaDoTiro = 20;
				break;
				
				case "TieInterceptor":
				naveEscolhida = new TieInterceptor();
				naveEscolhida.scaleX = 0.6;
				naveEscolhida.scaleY = 0.6;
				naveEscolhida.gotoAndStop(1);
				Main.getInstance().MC_tela.addChild(naveEscolhida);
				this.scaleX = 1.1;
				this.scaleY = 1.1;
				UI_vida = 300;
				NB_aceleracao = 0.6;								
				NB_desaceleracao = 0.3;								
				NB_velocidadeMax = 15;
				NB_velocidadeRot = 10;
				UI_forcaDoTiro = 8;								
				break;
				
				case "Tie":
				naveEscolhida = new Tie();
				naveEscolhida.scaleX = 0.7;
				naveEscolhida.scaleY = 0.7;
				naveEscolhida.gotoAndStop(1);
				Main.getInstance().MC_tela.addChild(naveEscolhida);
				this.scaleX = 1.6;
				this.scaleY = 1.3;
				UI_vida = 300;
				NB_aceleracao = 0.4;									
				NB_desaceleracao = 0.2;								
				NB_velocidadeMax = 10;
				NB_velocidadeRot = 8;
				UI_forcaDoTiro = 15;
				break;
				
				case "TieAdv":
				naveEscolhida = new TieAdv();
				naveEscolhida.scaleX = 0.9;
				naveEscolhida.scaleY = 0.9;
				naveEscolhida.gotoAndStop(1);
				Main.getInstance().MC_tela.addChild(naveEscolhida);
				this.scaleX = 1.8;
				this.scaleY = 1.5;
				UI_vida = 500;
				NB_aceleracao = 0.2;									
				NB_desaceleracao = 0.1;								
				NB_velocidadeMax = 10;
				NB_velocidadeRot = 5;
				UI_forcaDoTiro = 20;
				break;
			
				
			}
			
			UI_vidaMAX = UI_vida;				/** * especificando que a variavel vida Max é a vida inicial de cada nave, servindo para a proporcao da barra de HP*/
		}
		
		
		public function pressionar (e:KeyboardEvent):void
		{	
			if (UI_player == 1)					/** * definição de controles do player 1 (rotaçoes, aceleracao e freio, com animações)*/
			{
				switch (e.keyCode)
				{
					case Keyboard.A:
					BO_Esq = true;
					naveEscolhida.gotoAndStop(5);
					break;
					
					case Keyboard.D:
					BO_Dir = true;
					naveEscolhida.gotoAndStop(4);
					break;
					
					case Keyboard.W:
					BO_Acc = true;
					naveEscolhida.gotoAndStop(2);
					
					break;
					
					case Keyboard.S:
					BO_DesAcc = true;
					naveEscolhida.gotoAndStop(3);
					break;
					
					case Keyboard.SPACE:
					BO_Tiro = true;
					break;
				}
			}
			
			if (UI_player == 2)					/** * definição de controles do player 2 (rotaçoes, aceleracao e freio, com animações)*/
			{
				switch (e.keyCode)
				{
					case Keyboard.LEFT:
					BO_Esq = true;
					break;
					
					case Keyboard.RIGHT:
					BO_Dir = true;
					break;
					
					case Keyboard.UP:
					BO_Acc = true;
					break;
					
					case Keyboard.DOWN:
					BO_DesAcc = true;
					break;
					
					case Keyboard.NUMPAD_0:
					BO_Tiro = true;
					break;
				}
			}
		}
		
		
		public function soltar (e:KeyboardEvent):void
		{
			if (UI_player == 1)
			{
				switch (e.keyCode)
				{
					case Keyboard.A:
					BO_Esq = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.D:
					BO_Dir = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.W:
					BO_Acc = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.S:
					BO_DesAcc = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.SPACE:
					criarTiro();						/** * funcao de criar tiro ao soltar o botao de tiro*/
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					BO_Tiro = false;
				}
			}
			
			if (UI_player == 2)
			{
				switch (e.keyCode)
				{
					case Keyboard.LEFT:
					BO_Esq = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.RIGHT:
					BO_Dir = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.UP:
					BO_Acc = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.DOWN:
					BO_DesAcc = false;
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					break;
					
					case Keyboard.NUMPAD_0:
					criarTiro();						/** * funcao de criar tiro ao soltar o botao de tiro*/
					if (animacao != "parado") 
					{
						animacao = "parado";
						naveEscolhida.gotoAndStop(animacao);
					}
					BO_Tiro = false;
				}
			}
		}
		
		
		public function criarTiro()						/** * criando tiro*/
		{
			MC_tiro = new Tiro(UI_player,UI_forcaDoTiro, BO_pegouUpgrade, UI_tipoDoTiro);
			
			MC_tiro.x = this.x;							/** * criado na mesma posicao e rotacao do heroi*/
			MC_tiro.y = this.y;
			MC_tiro.rotation = this.rotation;
			
			if (UI_contadorDoTiro <= 70)				/** caso contador nao ultrapasse 70, tiro fraco*/
			{
				somTiro = tiro1.play();
			}
			
			if (UI_contadorDoTiro >= 70 && UI_contadorDoTiro <= 159)	/** * caso contador entre 70 e 159, tiro medio*/
			{
				MC_tiro.scaleX *= 2;					/** * tamanho *2 e força *3 */
				MC_tiro.scaleY *= 2;
				MC_tiro.UI_forca *= 3;
				somTiro = tiro1.play();
			}
			
			if (UI_contadorDoTiro >= 160)				/** * caso contador ultrapasse 160, tiro forte*/
			{
				MC_tiro.scaleX *= 3;					/** * tamanho maior ainda e força *8 */
				MC_tiro.scaleY *= 6;
				MC_tiro.UI_forca *= 8;
				somTiro = tiro2.play();					/** * outro som nesse caso*/
			}
			
			if (MC_energiaDoTiro != null)				/** * criar tiro, remover MC com energia do Tiro*/
			{
				Main.getInstance().MC_tela.removeChild(MC_energiaDoTiro);
				MC_energiaDoTiro = null;
			} 
			
			Main.getInstance().MC_tela.addChild(MC_tiro);	/** * adicionando tiro na tela*/
			Level.AR_tiros.push(MC_tiro);					/** * adicionando tiro na array de tiros*/
			UI_contadorDoTiro = 0;							/** * zerando contador de tiros*/
		}
		
		
		public function removerListener():void				/** * funcao para remover os eventos de controle do heroi*/
		{
			Main.getInstance().stage.removeEventListener(KeyboardEvent.KEY_UP, soltar);
			Main.getInstance().stage.removeEventListener(KeyboardEvent.KEY_DOWN, pressionar);
		}
		
		
		public function update():void						/** * update do heroi*/
		{
			this.x += NB_velocidadeX;
			this.y += NB_velocidadeY;
			
			naveEscolhida.alpha = 1;
			naveEscolhida.x = this.x;
			naveEscolhida.y = this.y;
			naveEscolhida.rotation = this.rotation;
			
			if (BO_Tiro == true)				/** * ao apertar o botao de tiro, dispara o contador e a animação*/
			{
				UI_contadorDoTiro++;				
				
				if (MC_energiaDoTiro == null) 
				{
					switch (nave)				/** * SWITCH responsavel pela mudanca dos MCs das energias de tiro de cada nave*/
					{
						case "XWing":
						MC_energiaDoTiro = new EnergiaXWing();
						MC_energiaDoTiro.scaleX = 0.5;
						MC_energiaDoTiro.scaleY = 0.5;
						Main.getInstance().MC_tela.addChild(MC_energiaDoTiro);
						break;
						
						case "YWing":
						MC_energiaDoTiro = new EnergiaYWing();
						MC_energiaDoTiro.scaleX = 0.4;
						MC_energiaDoTiro.scaleY = 0.4;
						Main.getInstance().MC_tela.addChild(MC_energiaDoTiro);
						break;
						
						case "Falcon":
						MC_energiaDoTiro = new EnergiaFalcon();
						MC_energiaDoTiro.scaleX = 0.4;
						MC_energiaDoTiro.scaleY = 0.4;
						Main.getInstance().MC_tela.addChild(MC_energiaDoTiro);
						break;
						
						case "TieInterceptor":
						MC_energiaDoTiro = new EnergiaTieInterceptor();
						MC_energiaDoTiro.scaleX = 0.6;
						MC_energiaDoTiro.scaleY = 0.6;
						Main.getInstance().MC_tela.addChild(MC_energiaDoTiro);
						break;				
						
						case "Tie":
						MC_energiaDoTiro = new EnergiaTie();
						MC_energiaDoTiro.scaleX = 0.7;
						MC_energiaDoTiro.scaleY = 0.7;
						Main.getInstance().MC_tela.addChild(MC_energiaDoTiro);
						break;
						
						case "TieAdv":
						MC_energiaDoTiro = new EnergiaTieAdv();
						MC_energiaDoTiro.scaleX = 0.9;
						MC_energiaDoTiro.scaleY = 0.9;
						Main.getInstance().MC_tela.addChild(MC_energiaDoTiro);
						break;				
					}
				}
				
				if (MC_energiaDoTiro != null)
				{
					MC_energiaDoTiro.x = naveEscolhida.x;
					MC_energiaDoTiro.y = naveEscolhida.y;
					MC_energiaDoTiro.rotation = naveEscolhida.rotation;
					
					if (UI_contadorDoTiro <= 69)					/** * animacao da energia das naves de acordo com o contador do tiro*/
					{
						if (animacaoCarregandoTiro != "tirofraco")
						{
							animacaoCarregandoTiro = "tirofraco";
							MC_energiaDoTiro.gotoAndStop(animacaoCarregandoTiro);
						}
					}
				
						
					else if (UI_contadorDoTiro >= 70 && UI_contadorDoTiro <= 159)
					{
						if (animacaoCarregandoTiro != "tiromedio")
						{
							somCanhao = carregandotiro1.play();
							animacaoCarregandoTiro = "tiromedio";
							MC_energiaDoTiro.gotoAndStop(animacaoCarregandoTiro);
						}
					}
						
					else if (UI_contadorDoTiro >= 160)
					{
						if (animacaoCarregandoTiro != "tiroforte")
						{
							somCanhao = carregandotiro2.play();
							animacaoCarregandoTiro = "tiroforte";
							MC_energiaDoTiro.gotoAndStop(animacaoCarregandoTiro);
						}
					}
				}	
			}
				
			if (BO_Dir == true)						/** * rotação para direita do heroi*/
			{
				this.rotation += NB_velocidadeRot;
				if (animacao != "direita") 
				{
					animacao = "direita";
					naveEscolhida.gotoAndStop(animacao);
				}
			}
			
			if (BO_Esq == true)						/** * rotação para esquerda do heroi*/
			{
				this.rotation -= NB_velocidadeRot;
				if (animacao != "esquerda") 
				{
					animacao = "esquerda";
					naveEscolhida.gotoAndStop(animacao);
				}
			}
			
			if (BO_Acc == true)
			{
				if (somTurbina != turbina.play())		/** * som da aceleração*/
				{
					somTurbina = turbina.play();
				}
				
				if (animacao != "acelerar") 		/** * animação da aceleração */
				{
					animacao = "acelerar";
					naveEscolhida.gotoAndStop(animacao);
				}
				
				if (this.rotation >= 0 && this.rotation <= 90)			/** * aceleração do heroi de acordo com o quadrante do angulo em q se encontra*/
				{
					NB_velocidadeX += (1 - this.rotation / 90) * NB_aceleracao;
					NB_velocidadeY += this.rotation / 90 * NB_aceleracao;
				}
				
				else if (this.rotation > 90 && this.rotation <= 180)
				{
					NB_velocidadeX += (1 - this.rotation / 90) * NB_aceleracao;
					NB_velocidadeY += (180 - this.rotation) / 90 * NB_aceleracao;
				}
				
				else if (this.rotation < 0 && this.rotation >= -90)
				{
					NB_velocidadeX += (this.rotation / 90 + 1) * NB_aceleracao;
					NB_velocidadeY += (this.rotation / 90) * NB_aceleracao;
				}
				
				else if (this.rotation < -90 && this.rotation >= -180)
				{
					NB_velocidadeX += (this.rotation / 90 + 1) * NB_aceleracao;
					NB_velocidadeY += (( -2) - this.rotation / 90) * NB_aceleracao;
				}
			}
			
			if (BO_DesAcc)								/** * desaceleração, sentido contrario das boleanas de aceleração*/
			{
				if (animacao != "freio") 				/** * animação de desaceleração */
				{
					animacao = "freio";
					naveEscolhida.gotoAndStop(animacao);
				}
				
				if (this.rotation >= 0 && this.rotation <= 90)
				{
					NB_velocidadeX -= (1 - this.rotation / 90) * NB_desaceleracao;
					NB_velocidadeY -= this.rotation / 90 * NB_desaceleracao;
				}
				
				else if (this.rotation > 90 && this.rotation <= 180)
				{
					NB_velocidadeX -= (1 - this.rotation / 90) * NB_desaceleracao;
					NB_velocidadeY -= (180 - this.rotation) / 90 * NB_desaceleracao;
				}
				
				else if (this.rotation < 0 && this.rotation >= -90)
				{
					NB_velocidadeX -= (this.rotation / 90 + 1) * NB_desaceleracao;
					NB_velocidadeY -= (this.rotation / 90) * NB_desaceleracao;
				}
				
				else if (this.rotation < -90 && this.rotation >= -180)
				{
					NB_velocidadeX -= (this.rotation / 90 + 1) * NB_desaceleracao;
					NB_velocidadeY -= (( -2) - this.rotation / 90) * NB_desaceleracao;
				}
			}
			
			if (this.x < -20)					/** * limites da tela, fazendo o heroi aparecer do outro lado*/
			{
				this.x = Main.getInstance().stage.stageWidth + 20;
			}
			
			else if (this.x > Main.getInstance().stage.stageWidth + 20)
			{
				this.x = -20
			}
			
			else if (this.y < -20)
			{
				this.y = stage.stageHeight +20;
			}
			
			else if (this.y > stage.stageHeight +20)
			{
				this.y = -20
			}
			
			if (NB_velocidadeX >= NB_velocidadeMax)			/** * limite da velocidade linear em X e Y, diferente para cada nave*/
			{
				NB_velocidadeX = NB_velocidadeMax;
			}
			
			else if (NB_velocidadeX <= - (NB_velocidadeMax))
			{
				NB_velocidadeX = -(NB_velocidadeMax);
			}
			
			if (NB_velocidadeY >= 15)
			{
				NB_velocidadeY = NB_velocidadeMax;
			}
			
			else if (NB_velocidadeY <= - (NB_velocidadeMax))
			{
				NB_velocidadeY = -(NB_velocidadeMax);
			}
			
			if (BO_pegouUpgrade == true)		/** * contador inicia qndo pega o upgrade*/
			{
				UI_tempoComUpgrade--;
			}
			
			if (UI_tempoComUpgrade == 0)		/** * ao chegar a zero, torna a remove o efeito do upgrade e volta o contador para o valor inicial*/
			{
				BO_pegouUpgrade = false;
				UI_tempoComUpgrade = 600;
			}
			
			if (UI_vida < 0)					/** * para o valor nao voltar a um numero absurdo (caso fosse uint), definir como 0 caso tente ficar negativado*/
			{
				UI_vida = 0;
			}
		}
	}
}